package A2353.qizhongThread;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

class BorderLayoutJPanel1 extends JPanel {
    JTextArea bCenter;
    BorderLayoutJPanel1() {
        super(new BorderLayout(10, 10)); // 设置外围边距
        String text = // 信息内容
                          "\n                                 欢迎进入Java多线程学习系统！\n\n"
                        + "   多线程是指在一个进程中同时执行多个线程，每个线程可以并行执行不同的任务。\n"
                        +"    线程是进程中的一个执行路径，多个线程共享同一个进程的资源，如内存空间和文件句柄\n";
        bCenter = new JTextArea(text);
        bCenter.setLineWrap(true);
        bCenter.setWrapStyleWord(true);
        bCenter.setFont(new Font("Serif", Font.PLAIN, 14));
        JScrollPane scrollPane = new JScrollPane(bCenter);
        add(scrollPane, BorderLayout.CENTER);
    }
}

class WindowMenu extends JFrame {
    JMenuBar menubar;
    JMenu menu, subMenu1, subMenu2;
    JMenuItem item1, item2, item3;

    WindowMenu() {
        init();
        this.setTitle("Java多线程学习系统");
        this.setSize(500, 300);
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        this.setVisible(true);
    }

    void init() {
        menubar = new JMenuBar();
        menu = new JMenu("菜单");
        subMenu1 = new JMenu("学习空间");
        subMenu2 = new JMenu("线程的应用");

        item1 = new JMenuItem("学习课堂");
        item2 = new JMenuItem("问卷调查");
        item3 = new JMenuItem("小游戏");


        // 添加菜单项到子菜单
        subMenu1.add(item1);
        subMenu1.add(item2);
        subMenu2.add(item3);


        // 添加子菜单到主菜单
        menu.add(subMenu1);
        menu.add(subMenu2);

        // 添加主菜单到菜单栏
        menubar.add(menu);

        // 设置菜单栏到JFrame
        this.setJMenuBar(menubar);
        BorderLayoutJPanel1 centerPanel = new BorderLayoutJPanel1();
        this.add(centerPanel, BorderLayout.CENTER); // 将中心面板添加到JFrame的内容窗格中
        // 监听器
        item2.addActionListener(e -> {
            new Survey().survey();
        });
        item3.addActionListener(e -> {
            new Game().startgame();
        });
        item1.addActionListener(e -> {
            new Learning().setVisible(true);
        });
    }
}
class Learning extends JFrame {
    // 继承自JFrame
    // 创建学习课堂界面
    JTextArea bCenter;

    // 构造函数，注意名称必须与类名一致
    public Learning() {
        setTitle("学习课堂");

        String text = // 信息内容
                "                                      欢迎进入Java多线程学习课堂！\n\n"
                        + "1. 什么是多线程？\n" +
                        "多线程是指在一个进程中同时执行多个线程。每个线程可以并行执行不同的任务。\n" +
                        "线程是进程中的一个执行路径，多个线程共享同一个进程的资源，如内存空间和文件句柄。\n"
                        + "2. 创建线程的方式\n" +
                        "           继承Thread类：通过继承java.lang.Thread类，并重写其run()方法来定义线程的行为。\n" +
                        "class MyThread extends Thread {\n" +
                        "    public void run() {\n" +
                        "        System.out.println(\"MyThread is running\");\n" +
                        "    }\n" +
                        "}\n" +
                        "           实现Runnable接口：通过实现java.lang.Runnable接口，并在run()方法中编写线程逻辑。\n" +
                        "class MyRunnable implements Runnable {\n" +
                        "    public void run() {\n" +
                        "        System.out.println(\"MyRunnable is running\");\n" +
                        "    }\n" +
                        "}\n"+
                        "3. 启动线程\n" +
                        "使用start()方法启动线程，而不是直接调用run()方法。\n" +
                        "new MyThread().start(); // 正确的方式\n" +
                        "new Thread(new MyRunnable()).start();\n" +
                        "4. 线程状态\n" +
                        "新建（New）：线程被创建但未启动。\n" +
                        "可运行（Runnable）：线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源。\n" +
                        "阻塞（Blocked）：线程暂时停止执行，直到某个条件满足。\n" +
                        "等待（Waiting）：线程无限期地等待另一个线程执行特定的操作。\n" +
                        "定时等待（Timed Waiting）：线程等待指定的时间。\n" +
                        "终止（Terminated）：线程完成执行或因异常退出。\n" +
                        "5. 线程优先级\n" +
                        "线程的优先级范围为1到10，默认优先级为5。优先级较高的线程更有可能获得处理器时间，但这并不是绝对的。\n" +
                        "Thread thread = new Thread(new MyRunnable());\n" +
                        "thread.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级";

        bCenter = new JTextArea(text);
        bCenter.setLineWrap(true); // 自动换行
        bCenter.setWrapStyleWord(true); // 按单词换行
        bCenter.setFont(new Font("Serif", Font.PLAIN, 14)); // 设置字体

        JScrollPane scrollPane = new JScrollPane(bCenter); // 添加滚动条
        add(scrollPane, BorderLayout.CENTER); // 将滚动条添加到窗体中心

        setSize(600, 400); // 设置窗体大小
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setLocationRelativeTo(null); // 窗体居中显示
        setVisible(true); // 显示窗体
    }
}

class Survey extends JFrame {
    JTextField text1,text2;
    JButton button, openButton, saveButton;
    JCheckBox checkBox1, checkBox2, checkBox3;
    JRadioButton radio1, radio2;
    ButtonGroup group;
    JComboBox<String> conBox; // 修改为泛型
    JTextArea area, resultArea; // 添加resultArea

    void survey() {
        setTitle("问卷调查");
        setSize(1200, 500);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        init();
        setVisible(true);

    }

    void init() {
        setLayout(new BorderLayout());

        Box northBox = Box.createVerticalBox();

        JPanel genderJPanel = new JPanel();
        group = new ButtonGroup();
        radio1 = new JRadioButton("是");
        radio2 = new JRadioButton("否");
        group.add(radio1);
        group.add(radio2);
        genderJPanel.add(new JLabel("是否在实际项目中使用过多线程："));
        genderJPanel.add(radio1);
        genderJPanel.add(radio2);
        northBox.add(genderJPanel);

        JPanel schoolPanel = new JPanel();
        schoolPanel.add(new JLabel("以下哪项方法可以启动一个线程？"));
        // 使用conBox代替局部声明的comBox
        conBox = new JComboBox<>(new String[] { "run()", "start()","execute()","call()" });
        schoolPanel.add(conBox);
        northBox.add(schoolPanel);

        JPanel understandPanel = new JPanel();
        understandPanel.add(new JLabel("在 Java 中，线程优先级的范围是："));
        text1 = new JTextField(20);
        text2 = new JTextField(20);
        understandPanel.add(text1);
        understandPanel.add(new JLabel("默认优先级为："));
        understandPanel.add(text2);
        northBox.add(understandPanel);

        JPanel conditionPanel = new JPanel();
        conditionPanel.add(new JLabel("下列关于线程生命周期的说法正确的是？（多选）"));
        checkBox1 = new JCheckBox("线程可以通过 `start()` 方法进入就绪状态");
        checkBox2 = new JCheckBox("线程在运行状态时可以直接回到新建状态");
        checkBox3 = new JCheckBox("线程可以通过 `sleep()` 进入阻塞状态");
        conditionPanel.add(checkBox1);
        conditionPanel.add(checkBox2);
        conditionPanel.add(checkBox3);
        northBox.add(conditionPanel);

        add(northBox, BorderLayout.NORTH);

        add(new JLabel("您在实际项目中遇到过哪些多线程相关的问题？是如何解决的？"));
        area = new JTextArea(6, 20);
        add(new JScrollPane(area), BorderLayout.CENTER);

        // 打开和保存按钮
        JPanel buttonPanel = new JPanel();
        openButton = new JButton("打开文件");
        saveButton = new JButton("保存文件");
        button = new JButton("提交");
        buttonPanel.add(openButton);
        buttonPanel.add(saveButton);
        buttonPanel.add(button);
        add(buttonPanel, BorderLayout.SOUTH);

        // 添加resultArea用于显示或编辑文件内容
        resultArea = new JTextArea(10, 30);
        add(new JScrollPane(resultArea), BorderLayout.EAST);

        // 添加事件监听器
        button.addActionListener(e -> JOptionPane.showMessageDialog(Survey.this, "提交成功！"));
        openButton.addActionListener(e -> openFile());
        saveButton.addActionListener(e -> saveFile());

    }

    public void openFile() {
        JFileChooser fileChooser = new JFileChooser();
        FileNameExtensionFilter filter = new FileNameExtensionFilter("Text Files", "txt");
        fileChooser.setFileFilter(filter);
        int returnVal = fileChooser.showOpenDialog(this);
        if (returnVal == JFileChooser.APPROVE_OPTION) {
            File file = fileChooser.getSelectedFile();
            try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
                resultArea.read(reader, null);
            } catch (IOException ex) {
                JOptionPane.showMessageDialog(this, "无法打开文件: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    public void saveFile() {
        JFileChooser fileChooser = new JFileChooser();
        FileNameExtensionFilter filter = new FileNameExtensionFilter("Text Files", "txt");
        fileChooser.setFileFilter(filter);
        int returnVal = fileChooser.showSaveDialog(this);
        if (returnVal == JFileChooser.APPROVE_OPTION) {
            File file = fileChooser.getSelectedFile();
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
                writer.write(resultArea.getText());
            } catch (IOException ex) {
                JOptionPane.showMessageDialog(this, "无法保存文件: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }
}
class Game extends JFrame {
    private static int score = 0; // 玩家得分
    private static boolean gameRunning = true; // 游戏是否运行
    private static JButton[] moleButtons = new JButton[9]; // 地鼠按钮数组
    private static JLabel scoreLabel; // 显示分数的标签
    private static JButton startbutton;
    private JFrame frame; // 主窗体

    void startgame() {
        // 初始化窗体
        init();

        // 重置游戏状态
        score = 0;
        scoreLabel.setText("得分: 0");
        gameRunning = true;

        // 启动地鼠生成线程
        Thread moleSpawner = new Thread(() -> spawnMoles());
        moleSpawner.start();

        // 启动计时器线程
        Thread timer = new Thread(() -> {
            try {
                Thread.sleep(30 * 1000); // 游戏持续时间：30秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            gameRunning = false; // 结束游戏
            JOptionPane.showMessageDialog(null, "游戏结束！你的得分是：" + score);
        });
        timer.start();
    }

    void init() {
        // 创建主窗体
        JFrame frame = new JFrame("打地鼠游戏");
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.setSize(400, 500);
        frame.setLayout(new BorderLayout());

        // 创建顶部分数显示区域
        JPanel topPanel = new JPanel();
        scoreLabel = new JLabel("得分: 0", SwingConstants.CENTER);
        scoreLabel.setFont(new Font("Arial", Font.BOLD, 20));
        topPanel.add(scoreLabel);
        frame.add(topPanel, BorderLayout.NORTH);

        // 创建中间的地鼠按钮区域
        JPanel buttonPanel = new JPanel(new GridLayout(3, 3));
        for (int i = 0; i < 9; i++) {
            moleButtons[i] = new JButton("");
            moleButtons[i].setFont(new Font("Arial", Font.BOLD, 20));
            final int index = i;
            moleButtons[i].addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (moleButtons[index].getText().equals("地鼠")) {
                        score++;
                        scoreLabel.setText("得分: " + score);
                        moleButtons[index].setText(""); // 击中后清除地鼠
                    }
                }
            });
            buttonPanel.add(moleButtons[i]);
        }
        frame.add(buttonPanel, BorderLayout.CENTER);

        // 创建底部控制区域
        JPanel bottomPanel = new JPanel();
        JButton startButton = new JButton("开始游戏");
        startButton.setFont(new Font("Arial", Font.BOLD, 16));
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                startGame();
            }
        });
        bottomPanel.add(startButton);
        frame.add(bottomPanel, BorderLayout.SOUTH);

        // 显示窗体
        frame.setVisible(true);
    }
    private void startGame(){
        score = 0;
        scoreLabel.setText("得分: 0");
        gameRunning = true;

        // 启动地鼠生成线程
        Thread moleSpawner = new Thread(() -> spawnMoles());
        moleSpawner.start();

        // 启动计时器线程
        //独立线程控制游戏时长，避免阻塞主UI线程。
        Thread timer = new Thread(() -> {
            try {
                Thread.sleep(30 * 1000); // 游戏持续时间：30秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            gameRunning = false; // 结束游戏
            JOptionPane.showMessageDialog(null, "游戏结束！你的得分是：" + score);
        });
        timer.start();
    }

    private void spawnMoles() {
        Random random = new Random();
        while (gameRunning) {
            int position = random.nextInt(9); // 随机生成地鼠位置（0-8）
            moleButtons[position].setText("地鼠");

            try {
                Thread.sleep(random.nextInt(2000) + 1000); // 地鼠存活时间：1-3秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (moleButtons[position].getText().equals("地鼠")) {
                moleButtons[position].setText(""); // 如果未被击中，则消失
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        new WindowMenu();
    }
}
